package lxj;

import org.junit.Test;

import java.util.*;

public class Demo {


    /*如果集合和数组中都是引用数据类型 那么他们之间可以相互转化*/


    @Test
    public void method1(){
        int [] arr={1,2,3,4};
        int len=arr.length;
        System.out.println("数组长度是"+len);

    }


    @Test   //数组遍历
    public void method2(){
        int [] arr={1,2,3,4};

        for (int i : arr) {
            System.out.print(i+"  ");
        }

        System.out.println();
        //方法二
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i]+"  ");
        }
    }


    @Test //数组元素反转     首位互换
    public void method3(){
        int [] arr={1,2,5,3,4};

        int temp;
        for (int i = 0,j=arr.length-1 ; i <j ; i++,j--) {          //很经典,两个条件
           temp=arr[i];
           arr[i]=arr[j];
           arr[j]=temp;
        }

        for (int i : arr) {
            System.out.print(i+"  ");
        }
    }



    @Test
    public void method4(){
        int [] arr={1,2,5,3,4};
        System.out.println(arr);
        System.out.println(arr.toString());
        System.out.println(Arrays.toString(arr));       //打印数组中的值


        // 对指定的 int 型数组按数字升序进行排序。
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));


        //将数组中的基本数据类型转化为引用数据类型，然后就可以转化为集合  就可以调用 reverse反转方法。
        Integer[] arrInteger=new Integer[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arrInteger[i]=arr[i];
        }
        List<Integer> list1 = Arrays.asList(arrInteger);
        Collections.reverse(list1);
        System.out.println(list1);

         //集合变数组
        Integer[] array = list1.toArray(new Integer[0]);
        System.out.println(Arrays.toString(array));

    }


    @Test
    public void method5(){
        Person [] arr={
                new Person("迪丽热巴",38),
                new Person("刘岩",18),
                new Person("古力拉扎",19)

        };


        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {

                //  return o1.getAge()-o2.getAge();                           //按年龄升序
                return o1.getName().length()-o2.getName().length();        //按姓名长度升序
            }
        });

        for (Person person : arr) {
            System.out.println(person);
        }

        //遍历数组
        System.out.println(Arrays.toString(arr));
    }




  @Test  //数组变集合   注意泛型必须为引用类型
    public void method6(){
      int[] arr = {2,4,6,8,10};
      //将数组中的基本数据类型转化为引用数据类型
      Integer[] arrInteger=new Integer[arr.length];
      for (int i = 0; i < arr.length; i++) {
          arrInteger[i]=arr[i];
      }


      List list = Arrays.asList(arr);
      List list1 = Arrays.asList(arrInteger);
      System.out.println("list中元素的个数" + list.size());
      System.out.println("list中元素的数据类型" +list.get(0).getClass());
      System.out.println("list1中元素的个数" + list1.size());
      System.out.println(list1);
      System.out.println("list1中元素的数据类型" + list1.get(0).getClass());

     // java.util类 Collections   中的方法 static void reverse(List<?> list)     集合反转

  }





  @Test   //集合变数组
    public void method7() {
      List<String> mlist = new ArrayList<>();
      mlist.add("zhu");
      mlist.add("wen");
      mlist.add("tao");

//集合时可以直接输出的,你是说这种情况。 因为打印的时候会调用它们各自的toString()方法，
// 而数组的toString是继承自Object类的，方法的返回如下。 而List集合中的toString继承自AbstractCollection，
// 也就是它重写了Object里定义的toString方法。其方法的返回如下。
      System.out.println(mlist);

      // List转成数组
      //List中的 toArray()方法  按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型

      //new String[1]指定数组中元素的类型
      String[] array = mlist.toArray(new String[1]);
      // 输出数组

      System.out.println(Arrays.toString(array));
  }



  @Test
    public void method8(){
      List arrlist = new ArrayList();
      //Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。
      Vector v = new Vector();
      // populate the vector
      v.add("A");
      v.add("B");
      v.add("C");
      v.add("D");
      v.add("E");
      // create enumeration
      Enumeration e = v.elements();  // 返回此向量的组件的枚举。
      // get the list
      arrlist = Collections.list(e);
      System.out.println(arrlist);
    }


  @Test   //数组降序  升序  反转问题
    public void method9(){
      int [] arr={1,2,5,3,4};
      //升序
      Arrays.sort(arr);
      System.out.println(Arrays.toString(arr));
      //反转降序
      int temp;
      for (int i = 0,j=arr.length-1 ; i <j ; i++,j--) {          //很经典,两个条件
          temp=arr[i];
          arr[i]=arr[j];
          arr[j]=temp;
      }

      System.out.println(Arrays.toString(arr));

    }



    @Test   //数组降序  升序  反转问题
    public void method10(){
        int[] arr = {2,4,10,8,6};

        //将数组中的基本数据类型转化为引用数据类型
        Integer[] arrInteger=new Integer[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arrInteger[i]=arr[i];
        }

        Arrays.sort(arrInteger, new Comparator<Integer>() {   //泛型 引用数据类型
            @Override
            public int compare(Integer o1, Integer o2) {
             //   return o1.intValue()-o2.intValue();      //升序
                return o2.intValue()-o1.intValue();        //降序
            }
        });


        //复制数组的方法
        Integer[] copy = Arrays.copyOfRange(arrInteger, 0, arrInteger.length);


        System.out.println(Arrays.toString(arrInteger));
    }



    @Test   //集合降序  升序  反转问题
    public void method11(){
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(2);
        list.add(5);


        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.intValue()-o2.intValue() ;
            }
        });

        System.out.println(list);
    }


    @Test  //数组去重
    public void method12() {
        int[] arr = {2,4,10,8,6,4,2};

        LinkedHashSet<Integer> set = new LinkedHashSet<>();

        for (int i : arr) {
          set.add(i);
        }

     //   Integer[] array= set.toArray(new Integer[0]);
        int[] arr2 = new int[set.size()];
        int i=0;
        for (Integer integer : set) {
           arr2[i]=integer;
           i++;
        }


        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer next = it.next();
            System.out.println(next);
        }

        System.out.println(Arrays.toString(arr2));

        System.out.println(set);
    }

    @Test  //集合中存储的元素,只能为<>括号中指定的数据类型元素; “”中的数据类型必须是引用数据类型,不能是基本数据类型
    public void method13() {
      List<Integer> list= new ArrayList<>();
      list.add(1);
      list.add(2);
      list.add(4);
      list.add(3);

        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.intValue()-o2.intValue();
            }
        });

        //集合转数组   数据类型必须为引用数据类型
          Integer[] arr=list.toArray(new Integer[0]);
    }

    @Test  //set 集合去重
    public void method14() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(3);

     //LinkedHashSet  有序添加不重复
        LinkedHashSet<Integer> set = new LinkedHashSet<>();

        for (Integer integer : list) {
            set.add(integer);
        }

        System.out.println(set);
    }
}


class Person{
    String name;
    int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
